import { defineStore } from 'pinia';
import { ElMessage } from 'element-plus';
import { appConfigApi, AppConfig, AppType } from '../api/appConfig';

// 应用配置常量
const APP_CONFIG_PREFIX = '[AppConfig]';

// 应用配置Store状态接口
interface AppConfigState {
  configList: AppConfig[];
  currentConfig: AppConfig | null;
  loading: boolean;
  submitting: boolean;
}

export const useAppConfigStore = defineStore({
  id: 'appConfig',
  
  state: (): AppConfigState => ({
    configList: [],
    currentConfig: null,
    loading: false,
    submitting: false,
  }),
  
  getters: {
    // 获取默认配置
    defaultConfig: (state) => state.configList.find(config => config.isDefault) || null,
    
    // 获取启用的配置列表
    enabledConfigs: (state) => state.configList.filter(config => config.isEnabled),
    
    // 获取配置总数
    configCount: (state) => state.configList.length,
    
    // 按类型获取配置
    getConfigsByType: (state) => (type: AppType) => {
      return state.configList.filter(config => config.type === type);
    }
  },
  
  actions: {
    // 获取所有应用配置
    async fetchConfigList() {
      this.loading = true;
      
      try {
        console.log(`${APP_CONFIG_PREFIX} 开始获取应用配置列表`);
        const response = await appConfigApi.getList();
        
        // 确保响应数据是数组
        if (Array.isArray(response)) {
          this.configList = response;
        } else {
          // 如果不是数组，可能是嵌套在data字段中或者是空的
          this.configList = (response && response.data && Array.isArray(response.data)) ? response.data : [];
          console.log(`${APP_CONFIG_PREFIX} 响应数据格式转换：`, response);
        }
        
        console.log(`${APP_CONFIG_PREFIX} 获取应用配置列表成功，共 ${this.configList.length} 条`);
        return this.configList;
      } catch (error: any) {
        console.error(`${APP_CONFIG_PREFIX} 获取应用配置列表错误:`, error);
        ElMessage.error(`获取应用配置失败: ${error.message || '未知错误'}`);
        throw error;
      } finally {
        this.loading = false;
      }
    },
    
    // 获取单个应用配置
    async fetchConfig(id: number | string) {
      this.loading = true;
      
      try {
        console.log(`${APP_CONFIG_PREFIX} 开始获取应用配置详情，ID: ${id}`);
        const response = await appConfigApi.getDetail(id);
        
        // 处理可能的嵌套数据结构
        if (response && response.data) {
          this.currentConfig = response.data;
        } else {
          this.currentConfig = response || null;
        }
        
        console.log(`${APP_CONFIG_PREFIX} 获取应用配置详情成功:`, this.currentConfig);
        return this.currentConfig;
      } catch (error: any) {
        console.error(`${APP_CONFIG_PREFIX} 获取应用配置详情错误:`, error);
        ElMessage.error(`获取应用配置详情失败: ${error.message || '未知错误'}`);
        throw error;
      } finally {
        this.loading = false;
      }
    },
    
    // 根据名称查找应用配置
    async findConfigByName(name: string) {
      this.loading = true;
      
      try {
        console.log(`${APP_CONFIG_PREFIX} 开始根据名称查找应用配置，名称: ${name}`);
        const response = await appConfigApi.findByName(name);
        
        // 处理可能的嵌套数据结构
        if (response && response.data) {
          this.currentConfig = response.data;
        } else {
          this.currentConfig = response || null;
        }
        
        console.log(`${APP_CONFIG_PREFIX} 根据名称查找应用配置成功:`, this.currentConfig);
        return this.currentConfig;
      } catch (error: any) {
        console.error(`${APP_CONFIG_PREFIX} 根据名称查找应用配置错误:`, error);
        ElMessage.error(`查找应用配置失败: ${error.message || '未知错误'}`);
        throw error;
      } finally {
        this.loading = false;
      }
    },
    
    // 获取默认应用配置
    async fetchDefaultConfig() {
      this.loading = true;
      
      try {
        console.log(`${APP_CONFIG_PREFIX} 开始获取默认应用配置`);
        const response = await appConfigApi.getDefault();
        
        // 处理可能的嵌套数据结构
        if (response && response.data) {
          this.currentConfig = response.data;
        } else {
          this.currentConfig = response || null;
        }
        
        console.log(`${APP_CONFIG_PREFIX} 获取默认应用配置成功:`, this.currentConfig);
        return this.currentConfig;
      } catch (error: any) {
        console.error(`${APP_CONFIG_PREFIX} 获取默认应用配置错误:`, error);
        ElMessage.error(`获取默认应用配置失败: ${error.message || '未知错误'}`);
        throw error;
      } finally {
        this.loading = false;
      }
    },
    
    // 创建应用配置
    async createConfig(configData: AppConfig) {
      this.submitting = true;
      
      try {
        console.log(`${APP_CONFIG_PREFIX} 开始创建应用配置`);
        const response = await appConfigApi.create(configData);
        
        // 处理可能的嵌套数据结构
        const configToAdd = response && response.data ? response.data : response;
        
        if (configToAdd) {
          // 添加到列表
          this.configList.push(configToAdd);
          
          // 如果设置为默认，更新其他配置
          if (configData.isDefault) {
            this.configList = this.configList.map(config => ({
              ...config,
              isDefault: config.id === configToAdd.id
            }));
          }
          
          console.log(`${APP_CONFIG_PREFIX} 创建应用配置成功`);
          ElMessage.success('创建应用配置成功');
          return configToAdd;
        }
        
        throw new Error('创建应用配置失败');
      } catch (error: any) {
        console.error(`${APP_CONFIG_PREFIX} 创建应用配置错误:`, error);
        ElMessage.error(`创建应用配置失败: ${error.message || '未知错误'}`);
        throw error;
      } finally {
        this.submitting = false;
      }
    },
    
    // 更新应用配置
    async updateConfig(id: number | string, configData: AppConfig) {
      this.submitting = true;
      
      try {
        console.log(`${APP_CONFIG_PREFIX} 开始更新应用配置，ID: ${id}`);
        const response = await appConfigApi.update(id, configData);
        
        // 处理可能的嵌套数据结构
        const configToUpdate = response && response.data ? response.data : response;
        
        if (configToUpdate) {
          // 更新列表中的配置
          const index = this.configList.findIndex(config => config.id === id);
          if (index !== -1) {
            this.configList[index] = configToUpdate;
            
            // 如果设置为默认，更新其他配置
            if (configToUpdate.isDefault) {
              this.configList = this.configList.map(config => ({
                ...config,
                isDefault: config.id === configToUpdate.id
              }));
            }
          }
          
          console.log(`${APP_CONFIG_PREFIX} 更新应用配置成功`);
          ElMessage.success('更新应用配置成功');
          return configToUpdate;
        }
        
        throw new Error('更新应用配置失败');
      } catch (error: any) {
        console.error(`${APP_CONFIG_PREFIX} 更新应用配置错误:`, error);
        ElMessage.error(`更新应用配置失败: ${error.message || '未知错误'}`);
        throw error;
      } finally {
        this.submitting = false;
      }
    },
    
    // 删除应用配置
    async deleteConfig(id: number | string) {
      this.submitting = true;
      
      try {
        console.log(`${APP_CONFIG_PREFIX} 开始删除应用配置，ID: ${id}`);
        await appConfigApi.delete(id);
        
        // 从列表中移除
        this.configList = this.configList.filter(config => config.id !== id);
        
        console.log(`${APP_CONFIG_PREFIX} 删除应用配置成功`);
        ElMessage.success('删除应用配置成功');
        return true;
      } catch (error: any) {
        console.error(`${APP_CONFIG_PREFIX} 删除应用配置错误:`, error);
        ElMessage.error(`删除应用配置失败: ${error.message || '未知错误'}`);
        throw error;
      } finally {
        this.submitting = false;
      }
    },
    
    // 设置默认配置
    async setDefaultConfig(id: number | string) {
      this.submitting = true;
      
      try {
        console.log(`${APP_CONFIG_PREFIX} 开始设置默认配置，ID: ${id}`);
        const response = await appConfigApi.setDefault(id);
        
        // 处理可能的嵌套数据结构
        const updatedConfig = response && response.data ? response.data : response;
        
        if (updatedConfig) {
          // 更新所有配置的默认状态
          this.configList = this.configList.map(config => ({
            ...config,
            isDefault: config.id === id
          }));
          
          console.log(`${APP_CONFIG_PREFIX} 设置默认配置成功`);
          ElMessage.success('设置默认配置成功');
          return updatedConfig;
        }
        
        throw new Error('设置默认配置失败');
      } catch (error: any) {
        console.error(`${APP_CONFIG_PREFIX} 设置默认配置错误:`, error);
        ElMessage.error(`设置默认配置失败: ${error.message || '未知错误'}`);
        throw error;
      } finally {
        this.submitting = false;
      }
    },
    
    // 修改配置状态
    async changeConfigStatus(id: number | string, isEnabled: boolean) {
      this.submitting = true;
      
      try {
        console.log(`${APP_CONFIG_PREFIX} 开始修改配置状态，ID: ${id}, 启用: ${isEnabled}`);
        const response = await appConfigApi.changeStatus(id, isEnabled);
        
        // 处理可能的嵌套数据结构
        const updatedConfig = response && response.data ? response.data : response;
        
        if (updatedConfig) {
          // 更新列表中的配置状态
          const index = this.configList.findIndex(config => config.id === id);
          if (index !== -1) {
            this.configList[index] = {
              ...this.configList[index],
              isEnabled
            };
          }
          
          console.log(`${APP_CONFIG_PREFIX} 修改配置状态成功`);
          ElMessage.success(`${isEnabled ? '启用' : '禁用'}配置成功`);
          return updatedConfig;
        }
        
        throw new Error('修改配置状态失败');
      } catch (error: any) {
        console.error(`${APP_CONFIG_PREFIX} 修改配置状态错误:`, error);
        ElMessage.error(`修改配置状态失败: ${error.message || '未知错误'}`);
        throw error;
      } finally {
        this.submitting = false;
      }
    }
  }
}); 